var __extends = (this && this.__extends) || (function () {
    var extendStatics = function (d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };
    return function (d, b) {
        if (typeof b !== "function" && b !== null)
            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
window.onload = function () {
    var str = "hello";
    console.log(str);
    var a1;
    var p1 = { id: 1, name: 'Jelly', age: 18 };
    var p1s = [
        { id: 1, name: 'Jelly', age: 18 },
        { id: 2, name: 'Hisun', age: 20 },
    ];
    var p2s = [
        { id: 1, name: 'Jelly', age: 18 },
        { id: 2, name: 'Hisun', age: 20 },
    ];
    // 函数
    function f1(n1, n2) {
        return n1 === n2;
    }
    f1(2, 3);
    // 表达式
    var f2 = function (x, y) {
    };
    f2(2, 3);
    var createObj = function (obj) {
        console.log("key: ".concat(obj.key, ", value: ").concat(obj.value));
    };
    var sun = { key: 'sun', value: 18 };
    createObj(sun);
    // 接口应用场景 - 函数中的输入类型和输出类型
    var sum1 = function (n1, n2) { return (n1 + n2); };
    sum1(2, 3);
    var sum2 = function (n1, n2) { return (n1 + n2); };
    sum2(2, 3);
    var o6 = {
        id: 1,
        name: 'woshi o6',
        dance: function (v) {
            return v;
        },
        say: function () {
            console.log(this.name);
            return 1;
        }
    };
    o6.say();
    var employee1 = {
        id: 1,
        name: '员工1',
        job: '大堂经理',
        idcard: 1245412,
    };
    // 泛型 - 泛型变量T, 表示任意类型 - 应用场景如下:
    // 定义函数, 函数传入参数, 返回值包含入参
    console.group('-----泛型');
    function f3(n1, n2) {
        return [n1, n2];
    }
    f3(2, 3);
    function f4(n1, n2) {
        return [n1, n2];
    }
    f4(2, 3);
    f4('nihao', 'shijie');
    function f5(str) {
        return str.length;
    }
    f5('hello');
    // function f6 (v1:number, v2:number):boolean {
    //   return v1 == v2
    // }
    var f6 = function (v1, v2) { return v1 == v2; };
    f6('10', '12');
    var f7 = function (v1, v2) {
        if (v1 > v2) {
            return true;
        }
        else {
            return false;
        }
    };
    f7(10, 12);
    console.groupEnd();
    console.group('-----类');
    var Animal = /** @class */ (function () {
        function Animal(name, age) {
            // 构造函数
            this.name = name;
            this.age = age;
        }
        Animal.prototype.action = function () {
            console.log("".concat(this.name, " action"));
        };
        return Animal;
    }());
    var an = new Animal('小明', 18);
    an.action();
    // js 构造函数 - 用来对比 ES6 class
    function Animal2(name, age) {
        this.name = name;
        this.age = age;
    }
    // 原型上共有属性
    Animal2.prototype.say = function () {
        console.log("".concat(this.name, " say"));
    };
    Animal2.prototype.action = function () {
        console.log("".concat(this.name, " action"));
    };
    var an2 = new Animal2('小红', 18);
    an2.say();
    // 类的继承,以及修饰符
    // public 公共属性或者方法, 默认值
    // private 私有属性或者方法, 只能在本类内部使用
    // protected 受保护的, 可以在本类以及继承的子类的内部使用
    var A = /** @class */ (function () {
        function A() {
            this.a = 'a';
            this.p = '保护属性P';
        }
        A.prototype.createA = function () {
            console.log('aaaaa');
        };
        return A;
    }());
    var aa1 = new A();
    // aa1.a // 无法访问私有属性和受保护属性
    var B = /** @class */ (function (_super) {
        __extends(B, _super);
        function B() {
            var _this = _super.call(this) || this; // 子类调用父类的构造器
            _this.b = 'b';
            return _this;
        }
        B.prototype.say = function () {
            console.log('子类访问: ', this.p);
        };
        return B;
    }(A));
    var bb1 = new B();
    bb1.createA();
    bb1.say();
    // bb1.a // 报错, 继承无法访问私有属性或方法
    console.groupEnd();
    console.group('-----类型断言');
    var count = 100;
    var count2 = count; // 自动推断类型
    console.log(typeof count2); // number
    // 符号: <> 和 as
    var num = count; // 类型断言
    var num2 = count; // 类型断言
    var oo1 = {};
    oo1.id = 111;
    oo1.title = 'title';
    console.groupEnd();
    console.group('-----修饰符');
    // infer 声明类型变量, 用于存储模式匹配中捕获的类型
    console.groupEnd();
};
